home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2004 #2 / Amiga Plus CD - 2004 - No. 02.iso / AmiSoft / Comm / tcp / JabberwockySRC.lha / Jabberwocky / src / prefs.c < prev    next >
Encoding:
C/C++ Source or Header  |  2003-02-10  |  16.8 KB  |  608 lines
  1. /*  Copyright (C) 2002 Tom Parker (tom@carrott.org),
  2.                        Matthias Münch (matthias@amigaworld.de)
  3.  
  4.     This program is free software; you can redistribute it and/or modify
  5.     it under the terms of the GNU General Public License as published by
  6.     the Free Software Foundation; either version 2 of the License, or
  7.     (at your option) any later version.
  8.  
  9.     This program is distributed in the hope that it will be useful,
  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.     GNU General Public License for more details.
  13.  
  14.     You should have received a copy of the GNU General Public License
  15.     along with this program; if not, write to the Free Software
  16.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17.  
  18.     In addition, as a special exception, Tom Parker and Matthias Münch give
  19.     permission to link the code of this program with a TCP stack of your 
  20.     choice, any official MUI libraries or classes and any custom MUI classes
  21.     that should be necessary for the operation of this program.  This 
  22.     exception also gives you permission to distribute linked combinations 
  23.     including this software with any of the before-mentioned libraries and 
  24.     classes.  You must obey the GNU General Public License in all respects for
  25.     all of the code used other than that provided by the before-mentioned 
  26.     libraries and classes.  As part of this exception you are obliged to 
  27.     follow the license terms of the before-mentioned libraries, this license
  28.     does not compel you to follow those terms, but if you do not then you may
  29.     not link with those libraries.  If you modify this file, you may extend
  30.     this exception to your version of the file, but you are not obligated to
  31.     do so.  If you do not wish to do so, delete this exception statement from
  32.     your version.
  33. */
  34. /*
  35. ** preferences
  36. */
  37.  
  38. #include "common.h"
  39.  
  40. #include <MUI/NListview_mcc.h>
  41. #include <libraries/asl.h>
  42.  
  43. #include "madthread.h"
  44.  
  45. struct prfevent events[] =
  46. {
  47.     { 0, "start", 0, NULL, NULL },
  48.     { 0, "quit", 0, NULL, NULL },
  49.     { 0, "online", 0, NULL, NULL },
  50.     { 0, "offline", 0, NULL, NULL },
  51.     { 0, "message", 0, NULL, NULL },
  52.     { 0, "chatmsg", 0, NULL, NULL },
  53.     { 0, "gcmsg", 0, NULL, NULL },
  54.     { NULL, 0, NULL },
  55.     NULL
  56. };
  57.  
  58. struct preferencesdata prf;
  59.  
  60. static ULONG prf_new(struct IClass *cl, Object *obj, struct opSet *msg);
  61. static MUI_LIST_DISP_DECL(event_disp, struct prfevent *pe);
  62. static void event_use(struct prefsdata *data);
  63. static void event_set(struct prefsdata *data);
  64. static void prf_use(struct prefsdata *data);
  65. static void prf_set(struct prefsdata *data);
  66. THREAD_DECL(runCommand);
  67.  
  68.  
  69. void prf_setup(int argc, char *argv[])
  70. {
  71.     events[EVT_STARTUP].name = MSG_PRF_EVENT_STARTUP;
  72.     events[EVT_EXIT].name = MSG_PRF_EVENT_EXIT;
  73.     events[EVT_ONLINE].name = MSG_PRF_EVENT_ONLINE;
  74.     events[EVT_OFFLINE].name = MSG_PRF_EVENT_OFFLINE;
  75.     events[EVT_MESSAGE].name = MSG_PRF_EVENT_INCOMING_MESSAGE;
  76.     events[EVT_CHAT].name = MSG_PRF_EVENT_INCOMING_CHAT;
  77.     events[EVT_GROUPCHAT].name = MSG_PRF_EVENT_INCOMING_GROUP_CHAT;
  78.     
  79.     memset(&net, 0, sizeof(struct netdata));
  80.     memset(&prf, 0, sizeof(struct preferencesdata));
  81.  
  82.     /* defaults */
  83.     prf.http_port = 80;
  84.  
  85.     prf.events[EVT_ONLINE].sound = iks_strdup("PROGDIR:sounds/online.iff");
  86.     prf.events[EVT_OFFLINE].sound = iks_strdup("PROGDIR:sounds/offline.iff");
  87.     prf.events[EVT_MESSAGE].sound = iks_strdup("PROGDIR:sounds/message.iff");
  88.  
  89.     prf.logfile = iks_strdup(JABBERWOCKY_LOG);
  90.  
  91.     prf_load("PROGDIR:"JABBERWOCKY_PREFS);
  92. }
  93.  
  94.  
  95. void prf_event(int evt, ...)
  96. {
  97.     if(prf.events[evt].flags & PRFE_SHOW)
  98.         set(gui.app, MUIA_Application_Iconified, FALSE);
  99.         
  100.     if (prf.events[evt].cmd) {
  101.         mt_run(&runCommand, prf.events[evt].cmd, NULL);
  102.     }
  103.     
  104. /*
  105.     if(prf.events[evt].flags & PRFE_SCRPOPUP)
  106.         DoMethod(win, MUIM_Window_ScreenToFront);
  107.     if(prf.events[evt].flags & PRFE_WINPOPUP)
  108.         DoMethod(win, MUIM_Window_ToFront);
  109. */
  110.  
  111.  
  112.     sound_play(prf.events[evt].sound);
  113. }
  114.  
  115.  
  116. THREAD(runCommand)
  117. {
  118.     mthread *t;
  119.  
  120.     t = mt_start();
  121.     if (!t) {
  122.         con_debug("event command thread initialisation failed!\n");
  123.         return;
  124.     }
  125.     
  126.     Execute((char *) t->data, NULL, NULL);
  127.     
  128.     mt_end(t);
  129.     return;
  130. }
  131.  
  132. #define GET_BOOL(node, attributeName) \
  133.         iks_strcmp(iks_find_attrib(node, attributeName), "true") == 0;
  134.  
  135. #define SET_BOOL(node, attributeName, value) \
  136.         iks_insert_attrib(node, attributeName, value ? "true" : "false");
  137.  
  138. void prf_load(char *fname)
  139. {
  140.     iks *x, *y;
  141.     int i;
  142.     
  143.     x = iks_load(fname);
  144.     
  145.     prf.autoconnect = GET_BOOL(x, "autoconnect");
  146.     prf.chatAsMessage = GET_BOOL(x, "chatAsMessage");
  147.     prf.messageAsChat = GET_BOOL(x, "messageAsChat");
  148.     prf.logfile = iks_strdup(iks_find_attrib(x, "logFile"));
  149.     prf.logIncoming = GET_BOOL(x, "logIncoming");
  150.     prf.logOutgoing = GET_BOOL(x, "logOutgoing");
  151.     prf.logDebug = GET_BOOL(x, "logDebug");
  152.     
  153.     y = iks_child(iks_find(x, "events"));
  154.     while(y)
  155.     {
  156.         if(iks_type(y) == IKS_TAG)
  157.         {
  158.             for(i=0; events[i].name; i++)
  159.             {
  160.                 if(iks_strcmp(iks_name(y), events[i].tag) == 0)
  161.                 {
  162.                     prf.events[i].sound = iks_strdup(iks_find_attrib(y, "sound"));
  163.                     prf.events[i].cmd = iks_strdup(iks_find_attrib(y, "cmd"));
  164.                     if(iks_find_attrib(y, "show")) prf.events[i].flags |= PRFE_SHOW;
  165.                     if(iks_find_attrib(y, "winpop")) prf.events[i].flags |= PRFE_WINPOPUP;
  166.                     if(iks_find_attrib(y, "scrpop")) prf.events[i].flags |= PRFE_SCRPOPUP;
  167.                     break;
  168.                 }
  169.             }
  170.         }
  171.         y = iks_next(y);
  172.     }
  173.     
  174.     iks_delete(x);
  175. }
  176.  
  177.  
  178. void prf_save(char *fname)
  179. {
  180.     iks *x, *y, *z;
  181.     int i;
  182.  
  183.     x = iks_new("jabberwocky");
  184.     
  185.     SET_BOOL(x, "autoconnect", prf.autoconnect);
  186.     if (prf.logfile) {
  187.         iks_insert_attrib(x, "logFile", prf.logfile);
  188.     }
  189.     SET_BOOL(x, "messageAsChat", prf.messageAsChat);
  190.     SET_BOOL(x, "chatAsMessage", prf.chatAsMessage);
  191.     SET_BOOL(x, "logIncoming", prf.logIncoming);
  192.     SET_BOOL(x, "logOutgoing", prf.logOutgoing);
  193.     SET_BOOL(x, "logDebug", prf.logDebug);
  194.     
  195.     y = iks_insert(x, "events");
  196.     for(i=0; events[i].name; i++)
  197.     {
  198.         z = iks_insert(y, events[i].tag);
  199.         iks_insert_attrib(z, "sound", prf.events[i].sound);
  200.         iks_insert_attrib(z, "cmd", prf.events[i].cmd);
  201.         if(prf.events[i].flags & PRFE_SHOW) iks_insert_attrib(z, "show", "yes");
  202.         if(prf.events[i].flags & PRFE_WINPOPUP) iks_insert_attrib(z, "winpop", "yes");
  203.         if(prf.events[i].flags & PRFE_SCRPOPUP) iks_insert_attrib(z, "scrpop", "yes");
  204.     }
  205.  
  206.     iks_save(fname, x);
  207.     iks_delete(x);
  208. }
  209.  
  210.  
  211. void prf_load_account(void)
  212. {
  213.     iks *x;
  214.  
  215.     x = iks_load(JABBERWOCKY_ACCFILE);
  216.     if(!x) return;
  217.     prf.user = iks_strdup(iks_find_cdata(x, "jid"));
  218.     prf.pass = iks_strdup(iks_find_cdata(x, "password"));
  219.     if(prf.pass) prf.savepass = 1;
  220.     iks_delete(x);
  221. }
  222.  
  223.  
  224. void prf_save_account(void)
  225. {
  226.     iks *x;
  227.  
  228.     x = iks_new("jabberwocky");
  229.     if(prf.user) iks_insert_cdata(iks_insert(x, "jid"), prf.user, -1);
  230.     if(prf.savepass && prf.pass)
  231.         iks_insert_cdata(iks_insert(x, "password"), prf.pass, -1);
  232.  
  233.     iks_save(JABBERWOCKY_ACCFILE, x);
  234.  
  235.     iks_delete(x);
  236. }
  237.  
  238.  
  239. MUI_DISPATCH(prefs_dispatch)
  240. {
  241.     switch(msg->MethodID)
  242.     {
  243.     case OM_NEW:
  244.         return prf_new(cl, obj, (APTR)msg);
  245.  
  246.     case PREFS_OPEN:
  247.         prf_set(INST_DATA(cl,obj));
  248.         set(obj, MUIA_Window_Open, TRUE);
  249.         return 0;
  250.  
  251.     case PREFS_LASTSAVED:
  252.         prf_load("PROGDIR:"JABBERWOCKY_PREFS);
  253. /* fix me */
  254.         return 0;
  255.  
  256.     case PREFS_SAVE:
  257.         prf_use(INST_DATA(cl,obj));
  258.         set(obj, MUIA_Window_Open, FALSE);
  259.         prf_save("PROGDIR:"JABBERWOCKY_PREFS);
  260.         return 0;
  261.  
  262.     case PREFS_USE:
  263.         prf_use(INST_DATA(cl,obj));
  264.         set(obj, MUIA_Window_Open, FALSE);
  265.         return 0;
  266.  
  267.     case PREFS_CANCEL:
  268.         set(obj, MUIA_Window_Open, FALSE);
  269.         return 0;
  270.  
  271.     case PREFS_PAGE:
  272.     {
  273.         struct prefsdata *data = INST_DATA(cl,obj);
  274.         u_long t;
  275.  
  276.         GetAttr(MUIA_NList_Active, data->pagelist, &t);
  277.         if(t == -1) return(0);
  278.         set(data->pagearea, MUIA_Group_ActivePage, t);
  279.  
  280.         return 0;
  281.     }
  282.  
  283.     case PREFS_TESTSND:
  284.     {
  285.         struct prefsdata *data = INST_DATA(cl,obj);
  286.         sound_play(mui_sget(data->sndstr));
  287.         return 0;
  288.     }
  289.  
  290.     case PREFS_ENTRY:
  291.         event_use(INST_DATA(cl,obj));
  292.         event_set(INST_DATA(cl,obj));
  293.         return 0;
  294.  
  295.     }
  296.     return DoSuperMethodA(cl, obj, msg);
  297. }
  298.  
  299.  
  300. static ULONG prf_new(struct IClass *cl, Object *obj, struct opSet *msg)
  301. {
  302.     static struct Hook dispHook = { {0,0}, &event_disp, NULL, NULL };
  303.     char *pages[] =
  304.     {
  305.         MSG_PRF_LIST_GENERAL,
  306.         MSG_PRF_LIST_LOCALE,
  307.         MSG_PRF_LIST_TRANSFER,
  308.         MSG_PRF_LIST_EVENTS,
  309.         MSG_PRF_LIST_ADVANCED,
  310.         NULL
  311.     };
  312.     struct prefsdata *data;
  313.     Object *pagelist, *pagearea, *savebut, *usebut, *canbut;
  314.     Object *autocontog, *recontog, *messageAsChatTog, *chatAsMessageTog;
  315.     Object *chartog, *isofilestr;
  316.     Object *eventlist, *showtog, *wintog, *scrtog, *cmdstr, *sndstr, *testbut;
  317.     Object *xintog, *xouttog, *debugtog, *logfilestr, *authtog;
  318.     int i;
  319.  
  320.     obj = (Object *)DoSuperNew(cl, obj,
  321.         MUIA_Window_ID, MAKE_ID('P','R','E','F'),
  322.         MUIA_Window_Title, "Preferences",
  323.         MUIA_HelpNode, "window-prefs",
  324.         WindowContents, VGroup,
  325.             Child, HGroup,
  326.                 Child, NListviewObject,
  327.                     MUIA_NListview_NList, (ULONG) pagelist = NListObject,
  328.                         InputListFrame,
  329.                         MUIA_ContextMenu, NULL,
  330.                         MUIA_NList_AdjustWidth, TRUE,
  331.                         MUIA_NList_SourceArray, pages,
  332.                         MUIA_CycleChain, 1,
  333.                     End,
  334.                 End,
  335.                 Child, (ULONG) pagearea = PageGroup,
  336.                     Child, VGroup,
  337.                         Child, MUI_MakeObject(MUIO_BarTitle, MSG_PRF_OPTIONS_TITLE),
  338.                         Child, mui_toggle(MSG_PRF_AUTOCONNECT, &autocontog),
  339.                         Child, mui_toggle(MSG_PRF_RECONNECT, &recontog),
  340.                         Child, mui_toggle(MSG_PRF_MESSAGE_AS_CHAT, &messageAsChatTog),
  341.                         Child, mui_toggle(MSG_PRF_CHAT_AS_MESSAGE, &chatAsMessageTog),
  342.                         Child, VSpace(0),
  343.                     End,
  344.                     Child, VGroup,
  345.                         Child, MUI_MakeObject(MUIO_BarTitle, MSG_PRF_CHARSET_TITLE),
  346.                         Child, mui_toggle("Internal (iso-8859-1)", &chartog),
  347.                         Child, HGroup,
  348.                             Child, Label2(MSG_PRF_CHARSET),
  349.                             Child, (ULONG) isofilestr = PopaslObject,
  350.                                 MUIA_Popstring_String, StringObject,
  351.                                     StringFrame,
  352.                                     MUIA_String_MaxLen, 256,
  353.                                     MUIA_CycleChain, 1,
  354.                                 End,
  355.                                 MUIA_Popstring_Button, PopButton(MUII_PopFile),
  356.                                 MUIA_Popasl_Type, ASL_FileRequest,
  357.                             End,
  358.                         End,
  359.                         Child, TextObject,
  360.                             TextFrame,
  361.                             MUIA_Background, MUII_TextBack,
  362.                             MUIA_Text_PreParse, "\33c",
  363.                         End,
  364.                         Child, VSpace(0),
  365.                     End,
  366.                     Child, VGroup,
  367.                         Child, HGroup,
  368.                             Child, Label2(MSG_PRF_XFER_PORT),
  369.                             Child, StringObject,
  370.                                 StringFrame,
  371.                                 MUIA_String_Accept, "0123456789",
  372.                                 MUIA_String_MaxLen, 6,
  373.                                 MUIA_CycleChain, 1,
  374.                             End,
  375.                         End,
  376.                         Child, VSpace(0),
  377.                     End,
  378.                     Child, VGroup,
  379.                         Child, NListviewObject,
  380.                             MUIA_NListview_NList, (ULONG) eventlist = NListObject,
  381.                                 InputListFrame,
  382.                                 MUIA_ContextMenu, NULL,
  383.                                 MUIA_NList_DisplayHook, &dispHook,
  384.                                 MUIA_CycleChain, 1,
  385.                             End,
  386.                         End,
  387.                         Child, HGroup,
  388.                             Child, mui_toggle(MSG_PRF_WINDOW_POPUP, &wintog),
  389.                             Child, mui_toggle(MSG_PRF_SCREEN_POPUP, &scrtog),
  390.                             Child, mui_toggle(MSG_PRF_DEICONIFY, &showtog),
  391.                         End,
  392.                         Child, ColGroup(2),
  393.                             Child, Label2(MSG_PRF_COMMAND),
  394.                             Child, (ULONG) cmdstr = PopaslObject,
  395.                                 MUIA_Popstring_String, StringObject,
  396.                                     StringFrame,
  397.                                     MUIA_String_MaxLen, 256,
  398.                                     MUIA_CycleChain, 1,
  399.                                 End,
  400.                                 MUIA_Popstring_Button, PopButton(MUII_PopFile),
  401.                                 MUIA_Popasl_Type, ASL_FileRequest,
  402.                             End,
  403.                             Child, Label2(MSG_PRF_SOUND),
  404.                             Child, HGroup,
  405.                                 Child, (ULONG) sndstr = PopaslObject,
  406.                                     MUIA_HorizWeight, 300,
  407.                                     MUIA_Popstring_String, StringObject,
  408.                                         StringFrame,
  409.                                         MUIA_String_MaxLen, 256,
  410.                                         MUIA_CycleChain, 1,
  411.                                     End,
  412.                                     MUIA_Popstring_Button, PopButton(MUII_PopFile),
  413.                                     MUIA_Popasl_Type, ASL_FileRequest,
  414.                                 End,
  415.                                 Child, testbut = mui_button(MSG_PRF_SOUNDTEST_GAD),
  416.                             End,
  417.                         End,
  418.                     End,
  419.                     Child, VGroup,
  420.                         Child, mui_toggle(MSG_PRF_PLAINTEXT_PASSWORDS, &authtog),
  421.                         Child, MUI_MakeObject(MUIO_BarTitle, MSG_PRF_LOG_TITLE),
  422.                         Child, HGroup,
  423.                             Child, mui_toggle(MSG_PRF_LOG_INCOMING_XML, &xintog),
  424.                             Child, mui_toggle(MSG_PRF_LOG_OUTGOING_XML, &xouttog),
  425.                             Child, mui_toggle(MSG_PRF_LOG_DEBUG, &debugtog),
  426.                         End,
  427.                         Child, HGroup,
  428.                             Child, Label2(MSG_PRF_LOGFILE),
  429.                             Child, (ULONG) logfilestr = PopaslObject,
  430.                                 MUIA_Popstring_String, StringObject,
  431.                                     StringFrame,
  432.                                     MUIA_String_MaxLen, 256,
  433.                                     MUIA_CycleChain, 1,
  434.                                 End,
  435.                                 MUIA_Popstring_Button, PopButton(MUII_PopFile),
  436.                                 MUIA_Popasl_Type, ASL_FileRequest,
  437.                             End,
  438.                         End,
  439.                         Child, VSpace(0),
  440.                     End,
  441.                 End,
  442.             End,
  443.             Child, RectangleObject,
  444.                 MUIA_FixHeightTxt, "M",
  445.                 MUIA_Rectangle_HBar, TRUE,
  446.             End,
  447.             Child, HGroup,
  448.                 Child, savebut = mui_button(MSG_PRF_SAVE_GAD),
  449.                 Child, usebut = mui_button(MSG_PRF_USE_GAD),
  450.                 Child, canbut = mui_button(MSG_PRF_CANCEL_GAD),
  451.             End,
  452.         End,
  453.         TAG_MORE, msg->ops_AttrList);
  454.  
  455.     if(!obj) return(0);
  456.  
  457.     for(i=0; events[i].name; i++)
  458.     {
  459.         DoMethod(eventlist, MUIM_NList_InsertSingle, &events[i], MUIV_NList_Insert_Bottom);
  460.     }
  461.  
  462.     data = INST_DATA(cl,obj);
  463.     data->pagelist = pagelist;
  464.     data->pagearea = pagearea;
  465.     data->autocontog = autocontog;
  466.     data->messageAsChatTog = messageAsChatTog;
  467.     data->chatAsMessageTog = chatAsMessageTog;
  468.     data->eventlist = eventlist;
  469.     data->showtog = showtog;
  470.     data->wintog = wintog;
  471.     data->scrtog = scrtog;
  472.     data->cmdstr = cmdstr;
  473.     data->sndstr = sndstr;
  474.     data->authtog = authtog;
  475.     data->logfilestr = logfilestr;
  476.     data->xintog = xintog;
  477.     data->xouttog = xouttog;
  478.     data->debugtog = debugtog;
  479.     data->lastitem = -1;
  480.  
  481.  
  482.  
  483.     DoMethod(eventlist, MUIM_Notify, MUIA_NList_Active, MUIV_EveryTime, obj, 1, PREFS_ENTRY);
  484.     DoMethod(testbut, MUIM_Notify, MUIA_Pressed, FALSE, obj, 1, PREFS_TESTSND);
  485.  
  486.     DoMethod(pagelist, MUIM_Notify, MUIA_NList_Active, MUIV_EveryTime, obj, 1, PREFS_PAGE);
  487.     DoMethod(savebut, MUIM_Notify, MUIA_Pressed, FALSE, obj, 1, PREFS_SAVE);
  488.     DoMethod(usebut, MUIM_Notify, MUIA_Pressed, FALSE, obj, 1, PREFS_USE);
  489.     DoMethod(canbut, MUIM_Notify, MUIA_Pressed, FALSE, obj, 1, PREFS_CANCEL);
  490.     DoMethod(obj, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, obj, 1, PREFS_CANCEL);
  491.     
  492.     return (ULONG)obj;
  493. }
  494.  
  495.  
  496. MUI_LIST_DISP_STATIC(event_disp, struct prfevent *pe)
  497. {
  498.     *array = pe->name;
  499.     if(pe->flags & PRFE_CHANGED)
  500.         array[DISPLAY_ARRAY_MAX] = "\33b";
  501.  
  502.     return 0;
  503. }
  504.  
  505.  
  506. static void event_use(struct prefsdata *data)
  507. {
  508.     u_long t, t2;
  509.  
  510.     t = data->lastitem;
  511.     if(t != MUIV_NList_Active_Off)
  512.     {
  513.         if(events[t].sound) free(events[t].sound);
  514.         events[t].sound = iks_strdup(mui_sget(data->sndstr));
  515.         if(events[t].cmd) free(events[t].cmd);
  516.         events[t].cmd = iks_strdup(mui_sget(data->cmdstr));
  517.         GetAttr(MUIA_Selected, data->showtog, &t2);
  518.         if(t2) events[t].flags |= PRFE_SHOW; else events[t].flags &= (~PRFE_SHOW);
  519.         GetAttr(MUIA_Selected, data->wintog, &t2);
  520.         if(t2) events[t].flags |= PRFE_WINPOPUP; else events[t].flags &= (~PRFE_WINPOPUP);
  521.         GetAttr(MUIA_Selected, data->scrtog, &t2);
  522.         if(t2) events[t].flags |= PRFE_SCRPOPUP; else events[t].flags &= (~PRFE_SCRPOPUP);
  523.     }
  524.     GetAttr(MUIA_NList_Active, data->eventlist, &t);
  525.     data->lastitem = t;
  526. }
  527.  
  528.  
  529. static void event_set(struct prefsdata *data)
  530. {
  531.     u_long t, i;
  532.  
  533.     GetAttr(MUIA_NList_Active, data->eventlist, &t);
  534.     if(t != MUIV_NList_Active_Off)
  535.     {
  536.         set(data->cmdstr, MUIA_String_Contents, (ULONG) events[t].cmd);
  537.         set(data->sndstr, MUIA_String_Contents, (ULONG) events[t].sound);
  538.         if(events[t].flags & PRFE_SHOW) i = TRUE; else i = FALSE;
  539.         set(data->showtog, MUIA_Selected, i);
  540.         if(events[t].flags & PRFE_WINPOPUP) i = TRUE; else i = FALSE;
  541.         set(data->wintog, MUIA_Selected, i);
  542.         if(events[t].flags & PRFE_SCRPOPUP) i = TRUE; else i = FALSE;
  543.         set(data->scrtog, MUIA_Selected, i);
  544.     }
  545. }
  546.  
  547. #define USE_FLAG(x,y) \
  548.     { \
  549.         ULONG temp; \
  550.         GetAttr(MUIA_Selected, x , &temp); \
  551.         if (temp) { \
  552.             y = 1; \
  553.         } else { \
  554.             y = 0; \
  555.         } \
  556.     }
  557.     
  558. static void prf_use(struct prefsdata *data)
  559. {
  560.     u_long t;
  561.     int i;
  562.  
  563.     event_use(data);
  564.     for(i=0; events[i].name; i++)
  565.     {
  566.         prf.events[i].sound = iks_strdup(events[i].sound);
  567.         prf.events[i].cmd = iks_strdup(events[i].cmd);
  568.         prf.events[i].flags = events[i].flags;
  569.     }
  570.  
  571.     prf.logfile = iks_strdup(mui_sget(data->logfilestr));
  572.     USE_FLAG(data->xintog, prf.logIncoming);
  573.     USE_FLAG(data->xouttog, prf.logOutgoing);
  574.     USE_FLAG(data->debugtog, prf.logDebug);
  575.  
  576.     USE_FLAG(data->authtog, prf.auth_method);
  577.  
  578.     USE_FLAG(data->autocontog, prf.autoconnect);
  579.     USE_FLAG(data->messageAsChatTog, prf.messageAsChat);
  580.     USE_FLAG(data->chatAsMessageTog, prf.chatAsMessage);
  581.     
  582. }
  583.  
  584. static void prf_set(struct prefsdata *data)
  585. {
  586.     u_long t;
  587.     int i;
  588.  
  589.     for(i=0; events[i].name; i++)
  590.     {
  591.         events[i].sound = iks_strdup(prf.events[i].sound);
  592.         events[i].cmd = iks_strdup(prf.events[i].cmd);
  593.         events[i].flags = prf.events[i].flags;
  594.     }
  595.     event_set(data);
  596.  
  597.     set(data->logfilestr, MUIA_String_Contents, (ULONG) prf.logfile);
  598.     set(data->xintog, MUIA_Selected, prf.logIncoming);
  599.     set(data->xouttog, MUIA_Selected, prf.logOutgoing);
  600.     set(data->debugtog, MUIA_Selected, prf.logDebug);
  601.  
  602.     set(data->authtog, MUIA_Selected, prf.auth_method);
  603.  
  604.     set(data->autocontog, MUIA_Selected, prf.autoconnect);
  605.     set(data->messageAsChatTog, MUIA_Selected, prf.messageAsChat);
  606.     set(data->chatAsMessageTog, MUIA_Selected, prf.chatAsMessage);
  607. }
  608.